{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:58.377985700Z",
     "start_time": "2023-09-06T05:29:58.361803Z"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install PyVirtualDisplay==3.0\n",
    "    !pip install gymnasium == 0.28.1\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01. DQN\n",
    "\n",
    "[V. Mnih et al., \"Human-level control through deep reinforcement learning.\" Nature, 518\n",
    "(7540):529–533, 2015.](https://storage.googleapis.com/deepmind-media/dqn/DQNNaturePaper.pdf)\n",
    "\n",
    "Reinforcement learning is known to be unstable or even to diverge when a nonlinear function approximator such as a neural network is used to represent the action-value (also known as $Q$) function. This instability has several causes: the correlations present in the sequence of observations, the fact that small updates to $Q$ may significantly change the policy and therefore change the data distribution, and the correlations between the action-values ($Q$) and the target values $r + \\gamma \\max_{a'} Q(s', a')$.\n",
    "\n",
    "The authors suggest two key ideas to address these instabilities with a novel variant of Q-learning: Replay buffer and Fixed Q-target.\n",
    "\n",
    "#### Uniformly random sampling from Experience Replay Memory\n",
    "\n",
    "Reinforcement learning agent stores the experiences consecutively in the buffer, so adjacent ($s, a, r, s'$) transitions stored are highly likely to have correlation. To remove this, the agent samples experiences uniformly at random from the pool of stored samples $\\big( (s, a, r, s') \\sim U(D) \\big)$. See sample_batch method of ReplayBuffer class for more details.\n",
    "\n",
    "#### Fixed Q-target\n",
    "\n",
    "DQN uses an iterative update that adjusts the action-values ($Q$) towards target values that are only periodically updated, thereby reducing correlations with the target; if not, it is easily divergy because the target continuously moves. The Q-learning update at iteration $i$ uses the following loss function:\n",
    "\n",
    "$$\n",
    "L_i(\\theta_i) = \\mathbb{E}_{(s,a,r,s') \\sim U(D)} \\big[ \\big( r + \\gamma \\max_{a'} Q(s',a';\\theta_i^-) - Q(s, a; \\theta_i) \\big)^2 \\big]\n",
    "$$\n",
    "\n",
    "in which $\\gamma$ is the discount factor determining the agent’s horizon, $\\theta_i$ are the parameters of the Q-network at iteration $i$ and $\\theta_i^-$ are the network parameters used to compute the target at iteration $i$. The target network parameters $\\theta_i^-$ are only updated with the Q-network parameters ($\\theta_i$) every C steps and are held fixed between individual updates. ($C = 200$ in CartPole-v0)\n",
    "\n",
    "#### For more stability: Gradient clipping\n",
    "\n",
    "The authors also found it helpful to clip the error term from the update $r + \\gamma \\max_{a'} Q(s', a'; \\theta_i^-) - Q(s,a,;\\theta_i)$ to be between -1 and 1. Because the absolute value loss function $|x|$ has a derivative of -1 for all negative values of x and a derivative of 1 for all positive values of x, clipping the squared error to be between -1 and 1 corresponds to using an absolute value loss function for errors outside of the (-1,1) interval. This form of error clipping further improved the stability of the algorithm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:59.708575600Z",
     "start_time": "2023-09-06T05:29:58.380988100Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\18213\\anaconda3\\envs\\Rainbow\\lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gymnasium as gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Typically, people implement replay buffers with one of the following three data structures:\n",
    "\n",
    "  - collections.deque\n",
    "  - list\n",
    "  - numpy.ndarray\n",
    "  \n",
    "**deque** is very easy to handle once you initialize its maximum length (e.g. deque(maxlen=buffer_size)). However, the indexing operation of deque gets terribly slow as it grows up because it is [internally doubly linked list](https://wiki.python.org/moin/TimeComplexity#collections.deque). On the other hands, **list** is an array, so it is relatively faster than deque when you sample batches at every step. Its amortized cost of  *Get item* is [O(1)](https://wiki.python.org/moin/TimeComplexity#list).\n",
    "\n",
    "Last but not least, let's see **numpy.ndarray**. numpy.ndarray is even faster than list due to the fact that it is [a homogeneous array of fixed-size items](https://docs.scipy.org/doc/numpy/reference/generated/numpy.ndarray.html#numpy.ndarray), so you can get the benefits of [locality of reference](https://en.wikipedia.org/wiki/Locality_of_reference). Whereas list is an array of pointers to objects, even when all of them are of the same type.\n",
    "\n",
    "Here, we are going to implement a replay buffer using numpy.ndarray.\n",
    "\n",
    "\n",
    "Reference: [OpenAI spinning-up](https://github.com/openai/spinningup/blob/master/spinup/algos/sac/sac.py#L10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:59.750473Z",
     "start_time": "2023-09-06T05:29:59.712478Z"
    }
   },
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)          # s  buffer\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)     # s' buffer\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)                  # a  buffer\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)                  # r  buffer\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)              # 标记一个 episode是否结束\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,        # s\n",
    "        act: np.ndarray,        # a\n",
    "        rew: float,             # r\n",
    "        next_obs: np.ndarray,   # s'\n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size       # 循环队列\n",
    "        self.size = min(self.size + 1, self.max_size)   # 新数据覆盖旧数据\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        # 随机选择 batch_size 个样本\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:59.763472200Z",
     "start_time": "2023-09-06T05:29:59.724478Z"
    }
   },
   "outputs": [],
   "source": [
    "class Network(nn.Module):  # 一个简单的多层感知机\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:59.775472100Z",
     "start_time": "2023-09-06T05:29:59.751472600Z"
    }
   },
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        seed: int,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.seed = seed\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)         # 训练网络\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)  # 目标网络\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()            # 随机选择 action\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()                                                  # 使用网络预测的值\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]      # [s, a]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, terminated, truncated, _ = self.env.step(action)\n",
    "        done = terminated or truncated\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]   # [s, a, r, s', done]\n",
    "            self.memory.store(*self.transition)             # 一种新奇的传参方式\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state, _ = self.env.reset(seed=self.seed)\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                '''\n",
    "                指数衰减：\n",
    "                min_epsilon + (max_epsilon - min_epsilon) * \n",
    "                    exp(-1. * frame_idx / epsilon_decay)\n",
    "                '''\n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()  # 将训练网络的参数拷贝到目标网络\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self, video_folder: str) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        # for recording a video\n",
    "        naive_env = self.env\n",
    "        self.env = gym.wrappers.RecordVideo(self.env, video_folder=video_folder)\n",
    "        \n",
    "        state, _ = self.env.reset(seed=self.seed)\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        # reset\n",
    "        self.env = naive_env\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "\n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        # Q(s, a)\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        # max_a'{Q(s', a')}\n",
    "        next_q_value = self.dqn_target(\n",
    "            next_state\n",
    "        ).max(dim=1, keepdim=True)[0].detach()\n",
    "        mask = 1 - done\n",
    "        # r + gamma * max_a'{Q(s', a')}\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)  # 均方误差\n",
    "\n",
    "        return loss\n",
    "\n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())  # 将训练网络拷贝到目标网络\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py) and [configurations](https://github.com/Farama-Foundation/Gymnasium/blob/main/gymnasium/envs/classic_control/cartpole.py#L91) of CartPole-v1 from Farama Gymnasium's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:59.802474300Z",
     "start_time": "2023-09-06T05:29:59.770472500Z"
    }
   },
   "outputs": [],
   "source": [
    "# environment\n",
    "env = gym.make(\"CartPole-v1\", max_episode_steps=200, render_mode=\"rgb_array\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:29:59.803492300Z",
     "start_time": "2023-09-06T05:29:59.786473Z"
    }
   },
   "outputs": [],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.cuda.manual_seed(seed)\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:00.833996300Z",
     "start_time": "2023-09-06T05:29:59.802474300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 10000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 100\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 2000x500 with 3 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:35.469494900Z",
     "start_time": "2023-09-06T05:30:34.439492100Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dqn\\rl-video-episode-0.mp4.\n",
      "Moviepy - Writing video C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dqn\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                              "
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready C:\\Users\\18213\\Source\\Rainbow Reading Notes\\videos\\dqn\\rl-video-episode-0.mp4\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  167.0\n"
     ]
    }
   ],
   "source": [
    "video_folder=\"videos/dqn\"\n",
    "agent.test(video_folder=video_folder)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2023-09-06T05:30:35.483475300Z",
     "start_time": "2023-09-06T05:30:35.443474600Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<IPython.core.display.HTML object>",
      "text/html": "\n        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n        <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\"/>\n        </video>\n        "
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Played: videos/dqn\\rl-video-episode-0.mp4\n"
     ]
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video width=\"320\" height=\"240\" alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "\n",
    "def show_latest_video(video_folder: str) -> str:\n",
    "    \"\"\"Show the most recently recorded video from video folder.\"\"\"\n",
    "    list_of_files = glob.glob(os.path.join(video_folder, \"*.mp4\"))\n",
    "    latest_file = max(list_of_files, key=os.path.getctime)\n",
    "    ipython_show_video(latest_file)\n",
    "    return latest_file\n",
    "\n",
    "\n",
    "latest_file = show_latest_video(video_folder=video_folder)\n",
    "print(\"Played:\", latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "name": "python3",
   "language": "python",
   "display_name": "Python 3 (ipykernel)"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
